package sys_ctl

import (
	"bytes"
	"fmt"
	"io"
	"math/rand"
	"net/http"
	"net/url"
	"os"
	"path"
	"strings"
	"time"
	"ubt-rbac-service/internal/app/model"
	"ubt-rbac-service/internal/app/model/sys_mod"
	"ubt-rbac-service/internal/app/service/sys_serv"
	"ubt-rbac-service/internal/app/util"
	"ubt-rbac-service/internal/core/config"
	"ubt-rbac-service/internal/core/convert"
	"ubt-rbac-service/internal/core/logger"
	"ubt-rbac-service/internal/core/parse"
)

type sysFile struct{}

var SysFileCtl sysFile

// UploadOss 上传文件
func (c *sysFile) UploadOss(w http.ResponseWriter, r *http.Request) {
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	//从表单中读取文件
	_, header, err := r.FormFile("upFile")
	if err != nil {
		logger.Error("文件获取失败。" + err.Error())
		util.ToJson(w, &model.ResJson{Code: 400, Msg: "文件获取失败"})
		return
	}
	result := util.UploadOss(header, 1)
	util.ToJson(w, result)
}

// DownloadOss 下载文件
func (c *sysFile) DownloadOss(w http.ResponseWriter, r *http.Request) {
	// 将请求的参数转换为请求结构体
	vo, errStr := parse.Parse(r, &sys_mod.SysFileDownOssReq{})
	if vo == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: errStr})
		return
	}
	req := vo.(*sys_mod.SysFileDownOssReq)
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	// 过滤关键参数值中的非法字符
	req.RealPath = util.InputFilter(req.RealPath, true)
	req.FileName = util.InputFilter(req.FileName, true)
	w.Header().Add("content-type", "application/octet-stream")
	w.Header().Add("content-disposition", "attachment; filename="+url.QueryEscape(req.FileName))
	w.Header().Add("Access-Control-Expose-Headers", "content-disposition")
	result := util.DownloadOss(req.RealPath)
	if result != nil && result.Code == 200 {
		buf := result.Data.(*bytes.Buffer)
		if _, err := w.Write(buf.Bytes()); err != nil {
			util.ToJson(w, &model.ResJson{Code: 500, Msg: "下载文件失败"})
		}
	} else {
		util.ToJson(w, result)
	}
}

// Upload 上传文件
func (c *sysFile) Upload(w http.ResponseWriter, r *http.Request) {
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	//从表单中读取文件
	file, header, err := r.FormFile("upFile")
	if err != nil {
		logger.Error("文件获取失败。" + err.Error())
		util.ToJson(w, &model.ResJson{Code: 400, Msg: "文件获取失败"})
		return
	}
	var fileName, extName, dateStr, basePath, baseUrl, filePath, srcPath, thumbPath, vstUrl, thumbUrl string
	basePath = config.GlobalConfig.FileConfig.BasePath + "/file/"
	baseUrl = config.GlobalConfig.FileConfig.BaseUrl + "/file/"
	dateStr = time.Now().Format("200601")
	fileName = header.Filename
	extName = path.Ext(fileName)
	extName = strings.ToLower(extName)
	fileName = fileName[:len(fileName)-len(extName)]
	var maxSize int64 = 200 * 1024 * 1024
	var kind uint8
	if !strings.Contains(".jpg.png.gif.bmp.jpeg.txt.xls.xlsx.doc.docx.pdf.zip.7z.rar.mp3.wma.mp4.mpeg", extName) {
		util.ToJson(w, &model.ResJson{Code: 403, Msg: "不允许上传的类型"})
		return
	}
	if strings.Contains(".jpg.png.gif.bmp.jpeg", extName) {
		kind = 1
		maxSize = 5 * 1024 * 1024
		filePath = basePath + "img/src/" + dateStr + "/"
		srcPath = basePath + "img/" + dateStr + "/"
		thumbPath = basePath + "img/thumb/" + dateStr + "/"
		vstUrl = baseUrl + "img/" + dateStr + "/"
		thumbUrl = baseUrl + "img/thumb/" + dateStr + "/"
		// 创建源文件的目录
		if _, err = os.Stat(srcPath); err != nil || os.IsNotExist(err) {
			if err = os.Mkdir(srcPath, os.ModePerm); err != nil {
				logger.Error("上传目录创建失败。" + err.Error())
				util.ToJson(w, &model.ResJson{Code: 500, Msg: "上传目录创建失败"})
				return
			}
		}
		// 创建缩略图的目录
		if _, err = os.Stat(thumbPath); err != nil || os.IsNotExist(err) {
			if err = os.Mkdir(thumbPath, os.ModePerm); err != nil {
				logger.Error("上传目录创建失败。" + err.Error())
				util.ToJson(w, &model.ResJson{Code: 500, Msg: "上传目录创建失败"})
				return
			}
		}
	} else if strings.Contains(".xls.xlsx.doc.docx.pdf", extName) {
		kind = 2
		filePath = basePath + "doc/" + dateStr + "/"
		vstUrl = baseUrl + "doc/" + dateStr + "/"
	} else if strings.Contains(".zip.7z.rar", extName) {
		kind = 3
		filePath = basePath + "zip/" + dateStr + "/"
		vstUrl = baseUrl + "zip/" + dateStr + "/"
	} else if strings.Contains(".mp3.wma.mp4.mpeg", extName) {
		kind = 4
		maxSize = 500 * 1024 * 1024
		filePath = basePath + "media/" + dateStr + "/"
		vstUrl = baseUrl + "media/" + dateStr + "/"
	} else {
		kind = 5
		filePath = basePath + "other/" + dateStr + "/"
		vstUrl = baseUrl + "other/" + dateStr + "/"
	}
	if maxSize < header.Size {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: "对不起，您上传的文件超出了大小限制，请重试！"})
		return
	}
	// 创建目录
	if _, err = os.Stat(filePath); err != nil || os.IsNotExist(err) {
		if err = os.Mkdir(filePath, os.ModePerm); err != nil {
			logger.Error("上传目录创建失败。" + err.Error())
			util.ToJson(w, &model.ResJson{Code: 500, Msg: "上传目录创建失败"})
			return
		}
	}
	//重命名文件
	newName := time.Now().Format("02150405") + fmt.Sprintf("%08v", rand.Intn(100000000)) + extName
	newFile, err := os.Create(filePath + newName)
	if err != nil {
		logger.Error("文件上传失败。" + err.Error())
		util.ToJson(w, &model.ResJson{Code: 500, Msg: "文件上传失败"})
		return
	}
	//将文件写到本地
	if _, err = io.Copy(newFile, file); err != nil {
		logger.Error("文件保存失败。" + err.Error())
		util.ToJson(w, &model.ResJson{Code: 500, Msg: "文件保存失败"})
		return
	}
	// 如果是图片格式的文件，则进行压缩和生成缩略图
	if strings.Contains(".jpg.png.gif.bmp.jpeg", extName) {
		// 压缩图片，高度设为0
		srcPath += newName
		util.ImgProc.ThumbImage(filePath+newName, srcPath, 1080, 0)
		// 生成缩略图
		thumbPath += newName
		util.ImgProc.ThumbImage(filePath+newName, thumbPath, 240, 240)
	}
	fileId := util.NewNanoid()
	req := &sys_mod.SysFileAddReq{
		FileId:   fileId,
		FileName: fileName,
		FileSize: header.Size,
		Kind:     kind,
		FileExt:  extName,
		RealPath: filePath + newName,
		VisitUrl: vstUrl + newName,
		OptOrg:   userInfo.DeptId,
	}
	result := sys_serv.SysFileServ.Add(req)
	if result != nil && result.RetCode == 1001 {
		fileInfo := make(map[string]string)
		fileInfo["id"] = fileId
		fileInfo["name"] = fileName
		fileInfo["url"] = vstUrl + newName
		fileInfo["thumb"] = thumbUrl + newName
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 1, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok", Data: fileInfo})
	} else {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: result.RetMsg})
	}
}

// UpImg4We 上传文件
func (c *sysFile) UpImg4We(w http.ResponseWriter, r *http.Request) {
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson4We(w, &model.RetJson{Errno: 401, Message: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	//从表单中读取文件
	file, header, err := r.FormFile("upImg")
	if err != nil {
		logger.Error("文件获取失败。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 400, Message: "文件获取失败"})
		return
	}
	var fileName, extName, dateStr, basePath, baseUrl, filePath, srcPath, thumbPath, vstUrl string
	basePath = config.GlobalConfig.FileConfig.BasePath + "/file/"
	baseUrl = config.GlobalConfig.FileConfig.BaseUrl + "/file/"
	dateStr = time.Now().Format("200601")
	fileName = header.Filename
	extName = path.Ext(fileName)
	extName = strings.ToLower(extName)
	fileName = fileName[:len(fileName)-len(extName)]
	var maxSize int64 = 5 * 1024 * 1024
	var kind uint8
	if !strings.Contains(".jpg.png.gif.bmp.jpeg", extName) {
		util.ToJson4We(w, &model.RetJson{Errno: 403, Message: "不允许上传的类型"})
		return
	}
	kind = 1
	filePath = basePath + "img/src/" + dateStr + "/"
	srcPath = basePath + "img/" + dateStr + "/"
	thumbPath = basePath + "img/thumb/" + dateStr + "/"
	vstUrl = baseUrl + "img/" + dateStr + "/"
	// 创建缩略图的目录
	if _, err = os.Stat(thumbPath); err != nil || os.IsNotExist(err) {
		if err = os.Mkdir(thumbPath, os.ModePerm); err != nil {
			logger.Error("上传目录创建失败。" + err.Error())
			util.ToJson(w, &model.ResJson{Code: 500, Msg: "上传目录创建失败"})
			return
		}
	}
	if maxSize < header.Size {
		util.ToJson4We(w, &model.RetJson{Errno: 400, Message: "对不起，您上传的文件超出了大小限制，请重试！"})
		return
	}
	// 创建目录
	if _, err = os.Stat(filePath); err != nil || os.IsNotExist(err) {
		if err = os.Mkdir(filePath, os.ModePerm); err != nil {
			logger.Error("上传目录创建失败。" + err.Error())
			util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "上传目录创建失败"})
			return
		}
	}
	// 创建源文件的目录
	if _, err = os.Stat(srcPath); err != nil || os.IsNotExist(err) {
		if err = os.Mkdir(srcPath, os.ModePerm); err != nil {
			logger.Error("上传目录创建失败。" + err.Error())
			util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "上传目录创建失败"})
			return
		}
	}
	//重命名文件
	newName := time.Now().Format("02150405") + fmt.Sprintf("%08v", rand.Intn(100000000)) + extName
	newFile, err := os.Create(filePath + newName)
	if err != nil {
		logger.Error("文件上传失败。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "文件上传失败"})
		return
	}
	//将文件写到本地
	if _, err = io.Copy(newFile, file); err != nil {
		logger.Error("文件保存失败。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "文件保存失败"})
		return
	}
	// 压缩图片，高度设为0
	srcPath += newName
	util.ImgProc.ThumbImage(filePath+newName, srcPath, 1080, 0)
	// 生成缩略图
	thumbPath += newName
	util.ImgProc.ThumbImage(filePath+newName, thumbPath, 240, 240)
	fileId := util.NewNanoid()
	req := &sys_mod.SysFileAddReq{
		FileId:   fileId,
		FileName: fileName,
		FileSize: header.Size,
		Kind:     kind,
		FileExt:  extName,
		RealPath: filePath + newName,
		VisitUrl: vstUrl + newName,
		OptOrg:   userInfo.DeptId,
	}
	result := sys_serv.SysFileServ.Add(req)
	if result != nil && result.RetCode == 1001 {
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 1, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		fileInfo := make(map[string]string)
		fileInfo["alt"] = fileName
		fileInfo["url"] = vstUrl + newName
		util.ToJson4We(w, &model.RetJson{Errno: 0, Message: "ok", Data: fileInfo})
	} else {
		util.ToJson4We(w, &model.RetJson{Errno: 500, Message: result.RetMsg})
	}
}

// Upvd4We 上传视频文件
func (c *sysFile) Upvd4We(w http.ResponseWriter, r *http.Request) {
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson4We(w, &model.RetJson{Errno: 401, Message: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	//从表单中读取文件
	file, header, err := r.FormFile("upVideo")
	if err != nil {
		logger.Error("文件获取失败。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 400, Message: "文件获取失败"})
		return
	}
	var fileName, extName, dateStr, basePath, baseUrl, filePath, srcPath, vstUrl string
	basePath = config.GlobalConfig.FileConfig.BasePath + "/file/"
	baseUrl = config.GlobalConfig.FileConfig.BaseUrl + "/file/"
	dateStr = time.Now().Format("200601")
	fileName = header.Filename
	extName = path.Ext(fileName)
	extName = strings.ToLower(extName)
	fileName = fileName[:len(fileName)-len(extName)]
	var maxSize int64 = 500 * 1024 * 1024
	var kind uint8
	if !strings.Contains(".mp4.mpeg", extName) {
		logger.Error("不允许上传的类型。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 403, Message: "不允许上传的类型"})
		return
	}
	kind = 4
	filePath = basePath + "media/" + dateStr + "/"
	vstUrl = baseUrl + "media/" + dateStr + "/"
	if maxSize < header.Size {
		util.ToJson4We(w, &model.RetJson{Errno: 400, Message: "对不起，您上传的文件超出了大小限制，请重试！"})
		return
	}
	// 创建目录
	if _, err = os.Stat(filePath); err != nil || os.IsNotExist(err) {
		if err = os.Mkdir(filePath, os.ModePerm); err != nil {
			logger.Error("上传目录创建失败。" + err.Error())
			util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "上传目录创建失败"})
			return
		}
	}
	//重命名文件
	newName := time.Now().Format("02150405") + fmt.Sprintf("%08v", rand.Intn(100000000)) + extName
	newFile, err := os.Create(filePath + newName)
	if err != nil {
		logger.Error("文件上传失败。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "文件上传失败"})
		return
	}
	//将文件写到本地
	if _, err = io.Copy(newFile, file); err != nil {
		logger.Error("文件保存失败。" + err.Error())
		util.ToJson4We(w, &model.RetJson{Errno: 500, Message: "文件保存失败"})
		return
	}
	// 如果是图片格式的文件，则进行压缩和生成缩略图
	if strings.Contains(".jpg.png.gif.bmp.jpeg", extName) {
		// 压缩图片，高度设为0
		srcPath += newName
		util.ImgProc.ThumbImage(filePath+newName, srcPath, 1080, 0)
		// 生成缩略图
	}
	fileId := util.NewNanoid()
	req := &sys_mod.SysFileAddReq{
		FileId:   fileId,
		FileName: fileName,
		FileSize: header.Size,
		Kind:     kind,
		FileExt:  extName,
		RealPath: filePath + newName,
		VisitUrl: vstUrl + newName,
		OptOrg:   userInfo.DeptId,
	}
	result := sys_serv.SysFileServ.Add(req)
	if result != nil && result.RetCode == 1001 {
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 1, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		fileInfo := make(map[string]string)
		fileInfo["alt"] = fileName
		fileInfo["url"] = vstUrl + newName
		util.ToJson4We(w, &model.RetJson{Errno: 0, Message: "ok", Data: fileInfo})
	} else {
		util.ToJson4We(w, &model.RetJson{Errno: 500, Message: result.RetMsg})
	}
}

// Download 下载文件
func (c *sysFile) Download(w http.ResponseWriter, r *http.Request) {
	// 将请求的参数转换为请求结构体
	vo, errStr := parse.Parse(r, &sys_mod.SysFileDownReq{})
	if vo == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: errStr})
		return
	}
	req := vo.(*sys_mod.SysFileDownReq)
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	// 过滤关键参数值中的非法字符
	req.FileId = util.InputFilter(req.FileId, true)
	realPath, fileName := sys_serv.SysFileServ.GetRealPath(req.FileId)
	if realPath == "" {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: "文件不存在"})
		return
	}
	if _, err := os.Stat(realPath); err != nil || os.IsNotExist(err) {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: "文件不存在"})
		return
	}
	fb, err := os.ReadFile(realPath)
	if err != nil {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: "读取文件失败"})
		return
	}
	w.Header().Add("content-type", "application/octet-stream")
	w.Header().Add("content-disposition", "attachment; filename="+url.QueryEscape(fileName))
	w.Header().Add("Access-Control-Expose-Headers", "content-disposition")
	if _, err = w.Write(fb); err != nil {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: "下载文件失败"})
	}
}

// UpdName 修改文件名称
func (c *sysFile) UpdName(w http.ResponseWriter, r *http.Request) {
	// 将请求的参数转换为请求结构体
	vo, errStr := parse.Parse(r, &sys_mod.SysFileNameReq{})
	if vo == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: errStr})
		return
	}
	req := vo.(*sys_mod.SysFileNameReq)
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	// 过滤关键参数值中的非法字符
	req.FileId = util.InputFilter(req.FileId, true)
	req.FileName = util.InputFilter(req.FileName, true)
	result := sys_serv.SysFileServ.UpdName(req)
	if result != nil && result.RetCode == 1001 {
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 3, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok"})
	} else {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: result.RetMsg})
	}
}

// UpdType 修改文件信息
func (c *sysFile) UpdType(w http.ResponseWriter, r *http.Request) {
	// 将请求的参数转换为请求结构体
	vo, errStr := parse.Parse(r, &sys_mod.SysFileTypeReq{})
	if vo == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: errStr})
		return
	}
	req := vo.(*sys_mod.SysFileTypeReq)
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	// 过滤关键参数值中的非法字符
	req.FileIds = util.InputFilter(req.FileIds, true)
	req.FileType = util.InputFilter(req.FileType, true)
	result := sys_serv.SysFileServ.UpdType(req)
	if result != nil && result.RetCode == 1001 {
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 3, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok"})
	} else {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: result.RetMsg})
	}
}

// Deletes 批量删除文件
func (c *sysFile) Deletes(w http.ResponseWriter, r *http.Request) {
	// 将请求的参数转换为结构体，并且校验请求的参数，如参数有误则会返回具体的错误结果
	vo, errStr := parse.Parse(r, &sys_mod.SysFileProReq{})
	if vo == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: errStr})
		return
	}
	req := vo.(*sys_mod.SysFileProReq)
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	// 过滤关键参数值中的非法字符
	req.FileIds = util.InputFilter(req.FileIds, true)
	result := sys_serv.SysFileServ.Deletes(req.FileIds)
	if result != nil && result.RetCode == 1001 {
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 2, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok"})
	} else {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: result.RetMsg})
	}
}

// Delete 删除文件
func (c *sysFile) Delete(w http.ResponseWriter, r *http.Request) {
	// 将请求的参数转换为结构体，并且校验请求的参数，如参数有误则会返回具体的错误结果
	vo, errStr := parse.Parse(r, &sys_mod.SysFileDelReq{})
	if vo == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: errStr})
		return
	}
	req := vo.(*sys_mod.SysFileDelReq)
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	// 过滤关键参数值中的非法字符
	req.FileId = util.InputFilter(req.FileId, true)
	result := sys_serv.SysFileServ.Delete(req.FileId)
	if result != nil && result.RetCode == 1001 {
		logReq := &sys_mod.SysLogSaveReq{UserId: userInfo.UserId, ModCode: "10010202", Kind: 2, OptOrg: userInfo.DeptId}
		sys_serv.SysLogServ.Add(logReq)
		util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok"})
	} else {
		util.ToJson(w, &model.ResJson{Code: 500, Msg: result.RetMsg})
	}
}

// One 获取文件信息详情
func (c *sysFile) One(w http.ResponseWriter, r *http.Request) {
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	u := r.URL.Query()
	if u == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: "对不起，请求的参数不能为空，请重试"})
		return
	}
	// 过滤关键参数值中的非法字符
	fileId := u.Get("fileId")
	fileId = util.InputFilter(fileId, true)
	if fileId == "" || len(fileId) != 21 {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: "对不起，请求的编号参数为空或不正确，请重试！"})
		return
	}
	result := sys_serv.SysFileServ.One(fileId)
	if result != nil && result.RetCode == 1001 {
		util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok", Data: result.RetData})
	} else {
		util.ToJson(w, &model.ResJson{Code: 404, Msg: result.RetMsg})
	}
}

// Page 获取文件分页列表
func (c *sysFile) Page(w http.ResponseWriter, r *http.Request) {
	// 通过头部请求的token获取用户信息
	token := r.Header.Get("token")
	userInfo := util.GetUserInfo(token)
	if userInfo == nil {
		util.ToJson(w, &model.ResJson{Code: 401, Msg: "对不起，您未登录或登录超时，请登录！"})
		return
	}
	u := r.URL.Query()
	if u == nil {
		util.ToJson(w, &model.ResJson{Code: 400, Msg: "对不起，请求的参数不能为空，请重试"})
		return
	}
	schName := u.Get("schName")
	fileType := u.Get("fileType")
	kinds := u.Get("kind")
	beginTimes := u.Get("beginTime")
	endTimes := u.Get("endTime")
	limits := u.Get("limit")
	offsets := u.Get("offset")
	schName = util.InputFilter(schName, false)
	fileType = util.InputFilter(fileType, true)
	kinds = util.InputFilter(kinds, true)
	beginTimes = util.InputFilter(beginTimes, true)
	endTimes = util.InputFilter(endTimes, true)
	limits = util.InputFilter(limits, true)
	offsets = util.InputFilter(offsets, true)
	kind := convert.Str2u8(kinds)
	beginTime := convert.Str2u32(beginTimes)
	endTime := convert.Str2u32(endTimes)
	limit := convert.Str2u8(limits)
	offset := convert.Str2u32(offsets)
	// 先统计信息的数量
	req := &sys_mod.SysFilePageReq{SchName: schName, FileType: fileType, Kind: kind, BeginTime: beginTime, EndTime: endTime, OptOrg: userInfo.DeptId}
	if result := sys_serv.SysFileServ.Count(req); result != nil && result.RetCode == 1001 && result.RetData.(int64) > 0 {
		res := &sys_mod.SysFilePageRes{Total: result.RetData.(int64)}
		// 再查询具体的信息列表
		req.Limit = limit
		req.Offset = offset
		if result = sys_serv.SysFileServ.Page(req); result != nil && result.RetCode == 1001 {
			res.List = result.RetData
			util.ToJson(w, &model.ResJson{Code: 200, Msg: "ok", Data: res})
			return
		}
	}
	util.ToJson(w, &model.ResJson{Code: 200, Msg: "暂无内容"})
}
